using System;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using Oracle.ManagedDataAccess.Types;
using OracleInternal.Common;
using OracleInternal.ServiceObjects;
using OracleInternal.TTC.Accessors;

namespace Oracle.ManagedDataAccess.Client
{
	[TypeConverter("Oracle.ManagedDataAccess.Client.OracleParameterTypeConverter")]
	public sealed class OracleParameter : DbParameter, IDisposable, ICloneable
	{
		internal string m_paramName;

		private string m_sourceColumn;

		private DbType m_dbType;

		private bool m_nullable;

		private object m_value;

		internal PrmEnumType m_enumType;

		private int m_offset;

		internal ParameterDirection m_direction;

		internal int m_bindElemCnt;

		internal int m_maxNoOfArrayElements;

		internal OracleDbType m_oraDbType;

		internal OraType m_oraType;

		internal int m_maxSize;

		internal bool m_modified;

		private DataRowVersion m_sourceVersion;

		private bool m_bSetDbType;

		internal int m_characterSetId;

		internal byte m_charSetForm;

		internal OracleCollectionType m_collType;

		internal bool m_disposed;

		internal int m_maxBytesToBeWrittenOrRead;

		internal int m_maxCharsToBeWrittenOrRead;

		internal bool m_bArrayBind;

		internal bool m_bDuplicateBind;

		private int[] m_maxArrayBindSize;

		private bool[] m_nullIndicatorsForArrayBind;

		private bool m_IsValueNull;

		internal OracleParameterCollection m_collRef;

		internal OracleParameterImpl m_paramImpl = new OracleParameterImpl();

		internal string m_paramPosOrName = string.Empty;

		internal bool m_bOracleDbTypeExSet;

		internal bool m_bReturnDateTimeOffset = true;

		private bool m_sourceColumnNullMapping;

		private const int MaxOraDbType = 135;

		private const int MinOraDbType = 101;

		private const int DataThresholdSizeForCLOB = 32768;

		private const int DataThresholdSizeForBLOB = 32768;

		internal const byte MaxScale = 127;

		internal const sbyte MinScale = -84;

		internal const int InvalidSize = -1;

		internal bool DuplicateBind
		{
			set
			{
				m_bDuplicateBind = true;
			}
		}

		[DefaultValue(false)]
		public bool SkipConversionToLocalTime
		{
			get
			{
				return m_paramImpl.m_bSkipConversionToLocalTime;
			}
			set
			{
				m_paramImpl.m_bSkipConversionToLocalTime = value;
			}
		}

		[Browsable(false)]
		[DefaultValue(null)]
		public int[] ArrayBindSize
		{
			get
			{
				if (m_paramImpl.m_curArrayBindSize != null && m_paramImpl.m_curArrayBindSize[0] != -1)
				{
					return m_paramImpl.m_curArrayBindSize;
				}
				if (m_maxArrayBindSize != null && m_maxArrayBindSize[0] != -1)
				{
					return m_maxArrayBindSize;
				}
				return null;
			}
			set
			{
				m_maxArrayBindSize = value;
				m_paramImpl.m_curArrayBindSize = null;
				m_modified = true;
			}
		}

		[DefaultValue(null)]
		[Browsable(false)]
		public OracleParameterStatus[] ArrayBindStatus
		{
			get
			{
				return m_paramImpl.m_arrayBindStatus;
			}
			set
			{
				m_paramImpl.m_arrayBindStatus = value;
				m_modified = true;
			}
		}

		[DefaultValue(OracleCollectionType.None)]
		[Browsable(false)]
		public OracleCollectionType CollectionType
		{
			get
			{
				return m_collType;
			}
			set
			{
				if (value != 0 && value != OracleCollectionType.PLSQLAssociativeArray)
				{
					throw new ArgumentOutOfRangeException();
				}
				m_collType = value;
			}
		}

		[Category("Data")]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
		[Description("")]
		public override DbType DbType
		{
			get
			{
				if (!m_bSetDbType)
				{
					m_dbType = (DbType)OraDb_DbTypeTable.dbTypeToOracleDbTypeMapping[(int)m_oraDbType];
					m_bSetDbType = true;
				}
				return m_dbType;
			}
			set
			{
				switch (value)
				{
				case DbType.Currency:
				case DbType.Guid:
				case DbType.SByte:
				case DbType.UInt16:
				case DbType.UInt32:
				case DbType.UInt64:
				case DbType.VarNumeric:
				case DbType.Xml:
				case DbType.DateTime2:
					throw new ArgumentException();
				default:
					throw new ArgumentOutOfRangeException();
				case DbType.AnsiString:
				case DbType.Binary:
				case DbType.Byte:
				case DbType.Boolean:
				case DbType.Date:
				case DbType.DateTime:
				case DbType.Decimal:
				case DbType.Double:
				case DbType.Int16:
				case DbType.Int32:
				case DbType.Int64:
				case DbType.Object:
				case DbType.Single:
				case DbType.String:
				case DbType.Time:
				case DbType.AnsiStringFixedLength:
				case DbType.StringFixedLength:
				case (DbType)24:
				case DbType.DateTimeOffset:
					m_dbType = value;
					m_oraDbType = (OracleDbType)OraDb_DbTypeTable.dbTypeToOracleDbTypeMapping[(int)value];
					m_bSetDbType = true;
					m_modified = true;
					m_enumType = PrmEnumType.DBTYPE;
					m_bOracleDbTypeExSet = false;
					break;
				}
			}
		}

		[DefaultValue(ParameterDirection.Input)]
		[Category("Data")]
		[Description("")]
		public override ParameterDirection Direction
		{
			get
			{
				return m_direction;
			}
			set
			{
				if (value != ParameterDirection.Input && value != ParameterDirection.Output && value != ParameterDirection.InputOutput && value != ParameterDirection.ReturnValue)
				{
					throw new ArgumentOutOfRangeException();
				}
				m_direction = value;
				m_modified = true;
			}
		}

		[DefaultValue(false)]
		[Category("Data")]
		[Description("")]
		public override bool IsNullable
		{
			get
			{
				return m_nullable;
			}
			set
			{
				m_nullable = value;
				m_modified = true;
			}
		}

		[DefaultValue(0)]
		[Browsable(false)]
		public int Offset
		{
			get
			{
				return m_offset;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException();
				}
				m_offset = value;
				m_modified = true;
			}
		}

		[Category("Data")]
		[Description("")]
		public OracleDbType OracleDbType
		{
			get
			{
				return m_oraDbType;
			}
			set
			{
				if (m_oraDbType != value)
				{
					if (value < OracleDbType.BFile || value > OracleDbType.Json)
					{
						throw new ArgumentOutOfRangeException();
					}
					m_oraDbType = value;
				}
				m_bSetDbType = false;
				m_enumType = PrmEnumType.ORADBTYPE;
				m_bOracleDbTypeExSet = false;
			}
		}

		[Description("")]
		[Category("Data")]
		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[DbProviderSpecificTypeProperty(true)]
		public OracleDbType OracleDbTypeEx
		{
			get
			{
				return m_oraDbType;
			}
			set
			{
				OracleDbType = value;
				m_bOracleDbTypeExSet = true;
			}
		}

		[DefaultValue("")]
		public override string ParameterName
		{
			get
			{
				if (m_paramName != null)
				{
					return m_paramName;
				}
				return string.Empty;
			}
			set
			{
				m_paramName = value;
			}
		}

		[DefaultValue(0)]
		[Description("")]
		[Category("Data")]
		public new byte Precision
		{
			get
			{
				if (m_paramImpl.m_precision == 100)
				{
					return 0;
				}
				return m_paramImpl.m_precision;
			}
			set
			{
				m_paramImpl.m_precision = value;
				m_modified = true;
			}
		}

		[Description("")]
		[Category("Data")]
		[DefaultValue(0)]
		public new byte Scale
		{
			get
			{
				if (m_paramImpl.m_scale == 129)
				{
					return 0;
				}
				return m_paramImpl.m_scale;
			}
			set
			{
				m_paramImpl.m_scale = value;
				m_modified = true;
			}
		}

		private int MaxCharsToBeWrittenOrRead
		{
			set
			{
				if (m_oraDbType != OracleDbType.Clob && m_oraDbType != OracleDbType.NClob && value > 0)
				{
					m_maxCharsToBeWrittenOrRead = value;
				}
			}
		}

		private int MaxBytesToBeWrittenOrRead
		{
			set
			{
				if (value > 0)
				{
					m_maxBytesToBeWrittenOrRead = value;
				}
			}
		}

		[Category("Data")]
		[Description("")]
		[DefaultValue(0)]
		public override int Size
		{
			get
			{
				if (m_paramImpl.m_curSize != -1)
				{
					return m_paramImpl.m_curSize;
				}
				if (m_maxSize != -1)
				{
					return m_maxSize;
				}
				return 0;
			}
			set
			{
				if (value < 0)
				{
					throw new ArgumentOutOfRangeException();
				}
				if (value != 0)
				{
					m_maxSize = value;
				}
				else
				{
					m_maxSize = -1;
				}
				m_paramImpl.m_curSize = -1;
			}
		}

		[Description("")]
		[DefaultValue("")]
		[Category("Data")]
		public override string SourceColumn
		{
			get
			{
				if (m_sourceColumn != null)
				{
					return m_sourceColumn;
				}
				return string.Empty;
			}
			set
			{
				m_sourceColumn = value;
			}
		}

		[DefaultValue(false)]
		public override bool SourceColumnNullMapping
		{
			get
			{
				return m_sourceColumnNullMapping;
			}
			set
			{
				m_sourceColumnNullMapping = value;
			}
		}

		[Description("")]
		[DefaultValue(DataRowVersion.Current)]
		[Category("Data")]
		public override DataRowVersion SourceVersion
		{
			get
			{
				return m_sourceVersion;
			}
			set
			{
				if (value != DataRowVersion.Original && value != DataRowVersion.Current && value != DataRowVersion.Proposed && value != DataRowVersion.Default)
				{
					throw new ArgumentOutOfRangeException();
				}
				m_sourceVersion = value;
			}
		}

		[DefaultValue(OracleParameterStatus.Success)]
		[Browsable(false)]
		public OracleParameterStatus Status
		{
			get
			{
				return m_paramImpl.m_status;
			}
			set
			{
				if (value != 0 && value != OracleParameterStatus.NullInsert && value != OracleParameterStatus.NullFetched && value != OracleParameterStatus.Truncation)
				{
					throw new ArgumentOutOfRangeException();
				}
				m_paramImpl.m_status = value;
				m_modified = true;
			}
		}

		[DefaultValue("")]
		[Description("")]
		[Category("Data")]
		public string UdtTypeName
		{
			get
			{
				return string.Empty;
			}
			set
			{
			}
		}

		[Description("")]
		[DefaultValue(null)]
		[Category("Data")]
		public override object Value
		{
			get
			{
				return m_value;
			}
			set
			{
				if (value != null && value != DBNull.Value && m_enumType == PrmEnumType.NOTSET)
				{
					Type type = value.GetType();
					if (type == typeof(sbyte) || type == typeof(ushort) || type == typeof(uint) || type == typeof(ulong))
					{
						throw new ArgumentException();
					}
					object obj = OraDb_DbTypeTable.s_table[type];
					if (obj == null && type.IsArray)
					{
						obj = OraDb_DbTypeTable.s_table[type.GetElementType()];
					}
					if (obj == null)
					{
						throw new ArgumentException();
					}
					m_oraDbType = (OracleDbType)obj;
					m_bSetDbType = false;
					m_enumType = PrmEnumType.VALUE;
				}
				m_value = value;
			}
		}

		public OracleParameter()
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				m_enumType = PrmEnumType.NOTSET;
				m_direction = ParameterDirection.Input;
				m_oraDbType = OracleDbType.Varchar2;
				m_maxSize = -1;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		public OracleParameter(string parameterName, OracleDbType oraType)
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				m_enumType = PrmEnumType.ORADBTYPE;
				m_direction = ParameterDirection.Input;
				if (oraType < OracleDbType.BFile || oraType > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_oraDbType = oraType;
				m_paramName = parameterName;
				m_maxSize = -1;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		public OracleParameter(string parameterName, object obj)
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (obj != null && obj != DBNull.Value)
				{
					Type type = obj.GetType();
					if (type == typeof(sbyte) || type == typeof(ushort) || type == typeof(uint) || type == typeof(ulong))
					{
						throw new ArgumentException();
					}
					object obj2 = OraDb_DbTypeTable.s_table[type];
					if (obj2 == null && type.IsArray)
					{
						obj2 = OraDb_DbTypeTable.s_table[type.GetElementType()];
					}
					if (obj2 == null)
					{
						throw new ArgumentException();
					}
					m_oraDbType = (OracleDbType)obj2;
					m_enumType = PrmEnumType.VALUE;
					m_value = obj;
				}
				else
				{
					m_oraDbType = OracleDbType.Varchar2;
					m_enumType = PrmEnumType.NOTSET;
				}
				m_direction = ParameterDirection.Input;
				m_paramName = parameterName;
				m_maxSize = -1;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		public OracleParameter(string parameterName, OracleDbType type, ParameterDirection direction)
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (direction != ParameterDirection.Input && direction != ParameterDirection.Output && direction != ParameterDirection.InputOutput && direction != ParameterDirection.ReturnValue)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_enumType = PrmEnumType.ORADBTYPE;
				m_direction = direction;
				if (type < OracleDbType.BFile || type > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_oraDbType = type;
				m_paramName = parameterName;
				m_maxSize = -1;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		public OracleParameter(string parameterName, OracleDbType type, int size)
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (size < 0)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (type < OracleDbType.BFile || type > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_enumType = PrmEnumType.ORADBTYPE;
				m_oraDbType = type;
				m_direction = ParameterDirection.Input;
				m_paramName = parameterName;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
				if (size != 0)
				{
					m_maxSize = size;
				}
				else
				{
					m_maxSize = -1;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		public OracleParameter(string parameterName, OracleDbType type, int size, string srcColumn)
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (size < 0)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (type < OracleDbType.BFile || type > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_enumType = PrmEnumType.ORADBTYPE;
				m_oraDbType = type;
				m_direction = ParameterDirection.Input;
				m_paramName = parameterName;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
				m_sourceColumn = srcColumn;
				if (size != 0)
				{
					m_maxSize = size;
				}
				else
				{
					m_maxSize = -1;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		public OracleParameter(string parameterName, OracleDbType type, object obj, ParameterDirection direction)
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (type < OracleDbType.BFile || type > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (direction != ParameterDirection.Input && direction != ParameterDirection.Output && direction != ParameterDirection.InputOutput && direction != ParameterDirection.ReturnValue)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_enumType = PrmEnumType.ORADBTYPE;
				m_oraDbType = type;
				m_direction = direction;
				m_paramName = parameterName;
				m_value = obj;
				m_maxSize = -1;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		internal OracleParameter(string parameterName, OracleDbType type, int size, string srcColumn, DataRowVersion version, object obj)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (type < OracleDbType.BFile || type > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (version != DataRowVersion.Original && version != DataRowVersion.Current && version != DataRowVersion.Proposed && version != DataRowVersion.Default)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_enumType = PrmEnumType.ORADBTYPE;
				m_oraDbType = type;
				m_direction = ParameterDirection.Input;
				m_paramName = parameterName;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
				m_sourceColumn = srcColumn;
				m_sourceVersion = version;
				m_value = obj;
				if (size != 0)
				{
					m_maxSize = size;
				}
				else
				{
					m_maxSize = -1;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		public OracleParameter(string parameterName, OracleDbType type, int size, object obj, ParameterDirection direction)
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (size < 0)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (type < OracleDbType.BFile || type > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (direction != ParameterDirection.Input && direction != ParameterDirection.Output && direction != ParameterDirection.InputOutput && direction != ParameterDirection.ReturnValue)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_enumType = PrmEnumType.ORADBTYPE;
				m_oraDbType = type;
				m_direction = direction;
				m_paramName = parameterName;
				m_value = obj;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
				if (size != 0)
				{
					m_maxSize = size;
				}
				else
				{
					m_maxSize = -1;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		public OracleParameter(string parameterName, OracleDbType oraType, int size, ParameterDirection direction, bool isNullable, byte precision, byte scale, string srcColumn, DataRowVersion srcVersion, object obj)
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (size < 0)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (direction != ParameterDirection.Input && direction != ParameterDirection.Output && direction != ParameterDirection.InputOutput && direction != ParameterDirection.ReturnValue)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (oraType < OracleDbType.BFile || oraType > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (srcVersion != DataRowVersion.Original && srcVersion != DataRowVersion.Current && srcVersion != DataRowVersion.Proposed && srcVersion != DataRowVersion.Default)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_enumType = PrmEnumType.ORADBTYPE;
				m_oraDbType = oraType;
				m_direction = direction;
				m_paramName = parameterName;
				m_paramImpl.m_precision = precision;
				m_paramImpl.m_scale = scale;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
				m_sourceColumn = srcColumn;
				m_sourceVersion = srcVersion;
				m_value = obj;
				m_nullable = isNullable;
				if (size != 0)
				{
					m_maxSize = size;
				}
				else
				{
					m_maxSize = -1;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		internal OracleParameter(DbType type, ParameterDirection direction, bool isNullable, int offSet, OracleDbType oraDbType, string paramName, byte precision, byte scale, int size, string srcColumn, DataRowVersion srcVersion, OracleParameterStatus paramStatus, object obj, bool bSetDbType, PrmEnumType enumType, bool modified)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
			}
			try
			{
				if (direction != ParameterDirection.Input && direction != ParameterDirection.Output && direction != ParameterDirection.InputOutput && direction != ParameterDirection.ReturnValue)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (oraDbType < OracleDbType.BFile || oraDbType > OracleDbType.Json)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				if (srcVersion != DataRowVersion.Original && srcVersion != DataRowVersion.Current && srcVersion != DataRowVersion.Proposed && srcVersion != DataRowVersion.Default)
				{
					GC.SuppressFinalize(this);
					throw new ArgumentOutOfRangeException();
				}
				m_enumType = enumType;
				m_modified = modified;
				m_oraDbType = oraDbType;
				m_direction = direction;
				m_paramName = paramName;
				m_paramImpl.m_precision = precision;
				m_paramImpl.m_scale = scale;
				m_sourceVersion = DataRowVersion.Current;
				m_paramImpl.m_curSize = -1;
				m_sourceColumn = srcColumn;
				m_sourceVersion = srcVersion;
				m_value = obj;
				m_nullable = isNullable;
				m_offset = offSet;
				m_paramImpl.m_status = paramStatus;
				if (size != 0)
				{
					m_maxSize = size;
				}
				else
				{
					m_maxSize = -1;
				}
				if (bSetDbType)
				{
					m_dbType = type;
					m_bSetDbType = true;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ctor);
				}
			}
		}

		private bool ShouldSerializeDbType()
		{
			return m_enumType == PrmEnumType.DBTYPE;
		}

		private bool ShouldSerializeOracleDbType()
		{
			return m_enumType != PrmEnumType.DBTYPE;
		}

		public object Clone()
		{
			OracleParameter oracleParameter = null;
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.Clone);
			}
			try
			{
				oracleParameter = ((m_value == null || !m_value.GetType().IsArray) ? new OracleParameter(m_dbType, m_direction, m_nullable, m_offset, m_oraDbType, m_paramName, m_paramImpl.m_precision, m_paramImpl.m_scale, m_maxSize, m_sourceColumn, m_sourceVersion, m_paramImpl.m_status, m_value, m_bSetDbType, m_enumType, m_modified) : new OracleParameter(m_dbType, m_direction, m_nullable, m_offset, m_oraDbType, m_paramName, m_paramImpl.m_precision, m_paramImpl.m_scale, m_maxSize, m_sourceColumn, m_sourceVersion, m_paramImpl.m_status, ((Array)m_value).Clone(), m_bSetDbType, m_enumType, m_modified));
				oracleParameter.m_collType = m_collType;
				oracleParameter.m_bOracleDbTypeExSet = m_bOracleDbTypeExSet;
				oracleParameter.m_bReturnDateTimeOffset = m_bReturnDateTimeOffset;
				return oracleParameter;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Public, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.Clone, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.Clone);
				}
			}
		}

		public void Dispose()
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.Dispose);
			}
			try
			{
				if (!m_disposed)
				{
					m_modified = true;
					m_disposed = true;
				}
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.Dispose);
				}
			}
		}

		public override void ResetDbType()
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ResetDbType);
			}
			try
			{
				m_enumType = PrmEnumType.NOTSET;
				DbType = DbType.String;
				OracleDbType = OracleDbType.Varchar2;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ResetDbType);
				}
			}
		}

		public void ResetOracleDbType()
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ResetOracleDbType);
			}
			try
			{
				m_enumType = PrmEnumType.NOTSET;
				DbType = DbType.String;
				OracleDbType = OracleDbType.Varchar2;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ResetOracleDbType);
				}
			}
		}

		public override string ToString()
		{
			if (ProviderConfig.m_bTraceLevelPublic)
			{
				Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ToString);
			}
			try
			{
				if (m_paramName != null)
				{
					return m_paramName;
				}
				return string.Empty;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPublic)
				{
					Trace.Write(OracleTraceLevel.Public, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.ToString);
				}
			}
		}

		private int GetBindingSize_Char(int idx)
		{
			int bufferLength = 0;
			bool flag = false;
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize_Char);
			}
			try
			{
				if (m_bArrayBind)
				{
					string[] array;
					char[][] array2;
					OracleString[] array3;
					if ((array = m_value as string[]) != null)
					{
						if (!m_nullIndicatorsForArrayBind[idx])
						{
							bufferLength = array[idx].Length;
						}
					}
					else if ((array2 = m_value as char[][]) != null)
					{
						if (!m_nullIndicatorsForArrayBind[idx])
						{
							bufferLength = array2[idx].Length;
						}
					}
					else if (m_value is char[])
					{
						bufferLength = 1;
					}
					else if ((array3 = m_value as OracleString[]) != null)
					{
						if (!m_nullIndicatorsForArrayBind[idx])
						{
							bufferLength = array3[idx].Length;
						}
					}
					else
					{
						flag = true;
					}
				}
				if (!m_bArrayBind || flag)
				{
					object obj = (m_bArrayBind ? ((Array)m_value).GetValue(idx) : m_value);
					string text;
					char[] array4;
					bufferLength = (((text = obj as string) != null) ? text.Length : (((array4 = obj as char[]) != null) ? array4.Length : ((obj is char) ? 1 : ((!(obj is OracleString)) ? Convert.ToString(obj)!.Length : ((OracleString)obj).Length))));
				}
				return GetBindingSize(bufferLength, idx);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize_Char, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize_Char);
				}
			}
		}

		private int GetBindingSize_Raw(int idx)
		{
			int bufferLength = 0;
			bool flag = false;
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize_Raw);
			}
			try
			{
				if (m_bArrayBind)
				{
					byte[][] array;
					OracleBinary[] array2;
					if ((array = m_value as byte[][]) != null)
					{
						bufferLength = array[idx].Length;
					}
					else if ((array2 = m_value as OracleBinary[]) != null)
					{
						bufferLength = array2[idx].Length;
					}
					else if (m_value is Guid[])
					{
						bufferLength = 16;
					}
					else
					{
						flag = true;
					}
				}
				if (!m_bArrayBind || flag)
				{
					object obj = null;
					obj = (m_bArrayBind ? ((Array)m_value).GetValue(idx) : m_value);
					byte[] array3;
					if ((array3 = obj as byte[]) != null)
					{
						bufferLength = array3.Length;
					}
					else if (obj is OracleBinary)
					{
						bufferLength = ((OracleBinary)obj).Length;
					}
					else
					{
						if (!(obj is Guid))
						{
							throw new ArgumentException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.PRM_INVALID_BIND));
						}
						bufferLength = 16;
					}
				}
				return GetBindingSize(bufferLength, idx);
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize_Raw, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize_Raw);
				}
			}
		}

		private int GetBindingSize(int bufferLength, int idx)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize);
			}
			try
			{
				int num = ((!m_bArrayBind) ? ((m_maxSize != -1) ? m_maxSize : bufferLength) : ((m_maxArrayBindSize[idx] != -1) ? m_maxArrayBindSize[idx] : bufferLength));
				if (m_offset > bufferLength)
				{
					throw new ArgumentException("Invalid offset", ParameterName);
				}
				if (m_offset + num > bufferLength)
				{
					num = bufferLength - m_offset;
				}
				return num;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.GetBindingSize);
				}
			}
		}

		internal void SetSize(int size)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetSize);
			}
			try
			{
				if (size != 0)
				{
					m_maxSize = size;
				}
				else
				{
					m_maxSize = -1;
				}
				m_paramImpl.m_curSize = -1;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetSize, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetSize);
				}
			}
		}

		internal static bool IsElemType(Type type, object value, int index)
		{
			Type left = null;
			bool result = false;
			if (value != null)
			{
				Array array = value as Array;
				if (array != null && array.Length > 0 && array.GetValue(index) != null)
				{
					left = array.GetValue(index)!.GetType();
				}
				result = left == type;
			}
			return result;
		}

		internal void PreBindFree()
		{
			try
			{
				if (m_oraDbType != OracleDbType.Blob && m_oraDbType != OracleDbType.Clob && m_oraDbType != OracleDbType.NClob)
				{
					m_paramImpl.m_saveValue = null;
					return;
				}
				int num = 1;
				if (m_direction != ParameterDirection.Input && m_direction != ParameterDirection.InputOutput)
				{
					return;
				}
				if (m_bArrayBind)
				{
					num = m_bindElemCnt;
				}
				if (m_paramImpl.m_saveValue == null)
				{
					return;
				}
				for (int i = 0; i < num; i++)
				{
					if (!(m_value is OracleBlob) && !IsElemType(typeof(OracleBlob), m_value, i))
					{
						object obj = m_paramImpl.m_saveValue[i];
						if (obj is OracleBlobImpl)
						{
							((OracleBlobImpl)obj).RelRef();
						}
						else if (obj is OracleClobImpl)
						{
							((OracleClobImpl)obj).RelRef();
						}
						m_paramImpl.m_saveValue[i] = null;
					}
				}
				m_paramImpl.m_saveValue = null;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, (OracleTraceTag)268697600, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBindFree, ex);
			}
		}

		internal void PreBind(OracleConnectionImpl connImpl, ColumnDescribeInfo cachedParamMetadata, ref bool bMetadataModified, int arrayBindCount, out ColumnDescribeInfo paramMetaData, out object paramValue, bool isEFSelectStatement, SqlStatementType stmtType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind);
			}
			try
			{
				m_maxBytesToBeWrittenOrRead = 1;
				m_maxCharsToBeWrittenOrRead = 0;
				m_bArrayBind = arrayBindCount != 0 || m_collType == OracleCollectionType.PLSQLAssociativeArray;
				if (m_bArrayBind)
				{
					SetArrayContext(arrayBindCount);
					m_paramImpl.m_paramValForArrayBindInBytes = new byte[m_bindElemCnt][];
					m_paramImpl.m_qLocatorDataForArrayBind = new byte[m_bindElemCnt][];
				}
				else
				{
					m_paramImpl.m_paramValInBytes = null;
				}
				SetNullIndicators();
				switch (m_oraDbType)
				{
				case OracleDbType.Char:
				case OracleDbType.Long:
				case OracleDbType.Varchar2:
					m_characterSetId = connImpl.m_serverCharacterSet;
					m_charSetForm = 1;
					PreBind_Char(connImpl, stmtType);
					break;
				case OracleDbType.Decimal:
					PreBind_Decimal();
					break;
				case OracleDbType.Boolean:
					PreBind_Boolean();
					break;
				case OracleDbType.Byte:
				case OracleDbType.Int16:
				case OracleDbType.Int32:
					PreBind_Int32();
					break;
				case OracleDbType.Int64:
					PreBind_Int64();
					break;
				case OracleDbType.Single:
					PreBind_Single();
					break;
				case OracleDbType.BinaryFloat:
					PreBind_BFloat();
					break;
				case OracleDbType.Double:
					PreBind_Double();
					break;
				case OracleDbType.BinaryDouble:
					PreBind_BDouble();
					break;
				case OracleDbType.Date:
					PreBind_Date();
					break;
				case OracleDbType.TimeStamp:
					PreBind_TimeStamp();
					break;
				case OracleDbType.TimeStampLTZ:
					PreBind_TimeStampLTZ(connImpl);
					break;
				case OracleDbType.TimeStampTZ:
					PreBind_TimeStampTZ(connImpl);
					break;
				case OracleDbType.IntervalDS:
					PreBind_IntervalDS();
					break;
				case OracleDbType.IntervalYM:
					PreBind_IntervalYM();
					break;
				case OracleDbType.RefCursor:
					PreBind_Cursor(connImpl);
					break;
				case OracleDbType.LongRaw:
				case OracleDbType.Raw:
					PreBind_Raw();
					break;
				case OracleDbType.Clob:
					m_charSetForm = 1;
					m_characterSetId = connImpl.m_serverCharacterSet;
					PreBind_Clob(connImpl, isEFSelectStatement, stmtType);
					break;
				case OracleDbType.NClob:
					m_charSetForm = 2;
					m_characterSetId = connImpl.m_serverNCharSet;
					PreBind_Clob(connImpl, isEFSelectStatement, stmtType);
					break;
				case OracleDbType.Blob:
					PreBind_Blob(connImpl, isEFSelectStatement);
					break;
				case OracleDbType.BFile:
					PreBind_BFile(connImpl);
					break;
				case OracleDbType.Json:
					PreBind_Json(connImpl);
					break;
				case OracleDbType.NChar:
				case OracleDbType.NVarchar2:
					m_characterSetId = connImpl.m_serverNCharSet;
					m_charSetForm = 2;
					PreBind_Char(connImpl, stmtType);
					break;
				case OracleDbType.XmlType:
					PreBind_XmlType(connImpl);
					break;
				default:
					throw new OracleException(ResourceStringConstants.CMD_TYPE_NOT_SUPPORTED, string.Empty, string.Empty, OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.CMD_TYPE_NOT_SUPPORTED));
				}
				paramMetaData = m_paramImpl.GetParameterMetaData(this, cachedParamMetadata, ref bMetadataModified);
				paramValue = (m_bArrayBind ? ((object)m_paramImpl.m_paramValForArrayBindInBytes) : ((object)m_paramImpl.m_paramValInBytes));
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind);
				}
			}
		}

		private bool IsProviderSpecificNullValue(object value)
		{
			bool result = false;
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.IsProviderSpecificNullValue);
			}
			try
			{
				switch (m_oraDbType)
				{
				case OracleDbType.Char:
				case OracleDbType.Long:
				case OracleDbType.NChar:
				case OracleDbType.NVarchar2:
				case OracleDbType.Varchar2:
				case OracleDbType.Json:
					if (value is OracleString && ((OracleString)value).IsNull)
					{
						result = true;
					}
					break;
				case OracleDbType.Boolean:
					if (value is OracleBoolean && ((OracleBoolean)value).IsNull)
					{
						result = true;
					}
					break;
				case OracleDbType.BFile:
				{
					OracleBFile oracleBFile = null;
					if ((oracleBFile = value as OracleBFile) != null && oracleBFile.IsNull)
					{
						result = true;
					}
					break;
				}
				case OracleDbType.Blob:
				{
					OracleBlob oracleBlob = null;
					if (((oracleBlob = value as OracleBlob) != null && oracleBlob.IsNull) || (value is OracleBinary && ((OracleBinary)value).IsNull))
					{
						result = true;
					}
					break;
				}
				case OracleDbType.Byte:
					if ((value is OracleDecimal && ((OracleDecimal)value).IsNull) || (value is OracleString && ((OracleString)value).IsNull))
					{
						result = true;
					}
					break;
				case OracleDbType.Clob:
				case OracleDbType.NClob:
				{
					OracleClob oracleClob2 = null;
					if (((oracleClob2 = value as OracleClob) != null && oracleClob2.IsNull) || (value is OracleString && ((OracleString)value).IsNull))
					{
						result = true;
					}
					break;
				}
				case OracleDbType.XmlType:
				{
					OracleXmlType oracleXmlType = null;
					OracleClob oracleClob = null;
					if (((oracleXmlType = value as OracleXmlType) != null && oracleXmlType.IsNull) || ((oracleClob = value as OracleClob) != null && oracleClob.IsNull) || (value is OracleString && ((OracleString)value).IsNull))
					{
						result = true;
					}
					break;
				}
				case OracleDbType.Date:
				case OracleDbType.TimeStamp:
				case OracleDbType.TimeStampLTZ:
				case OracleDbType.TimeStampTZ:
					if ((value is OracleDate && ((OracleDate)value).IsNull) || (value is OracleString && ((OracleString)value).IsNull) || (value is OracleTimeStamp && ((OracleTimeStamp)value).IsNull) || (value is OracleTimeStampTZ && ((OracleTimeStampTZ)value).IsNull) || (value is OracleTimeStampLTZ && ((OracleTimeStampLTZ)value).IsNull))
					{
						result = true;
					}
					break;
				case OracleDbType.Decimal:
				case OracleDbType.Double:
				case OracleDbType.Int16:
				case OracleDbType.Int32:
				case OracleDbType.Int64:
				case OracleDbType.Single:
				case OracleDbType.BinaryDouble:
				case OracleDbType.BinaryFloat:
					if ((value is OracleDecimal && ((OracleDecimal)value).IsNull) || (value is OracleString && ((OracleString)value).IsNull))
					{
						result = true;
					}
					break;
				case OracleDbType.IntervalDS:
					if ((value is OracleIntervalDS && ((OracleIntervalDS)value).IsNull) || (value is OracleString && ((OracleString)value).IsNull))
					{
						result = true;
					}
					break;
				case OracleDbType.IntervalYM:
					if ((value is OracleIntervalYM && ((OracleIntervalYM)value).IsNull) || (value is OracleString && ((OracleString)value).IsNull))
					{
						result = true;
					}
					break;
				case OracleDbType.LongRaw:
				case OracleDbType.Raw:
					if (value is OracleBinary && ((OracleBinary)value).IsNull)
					{
						result = true;
					}
					break;
				case OracleDbType.RefCursor:
				{
					OracleRefCursor oracleRefCursor = null;
					if ((oracleRefCursor = value as OracleRefCursor) != null && oracleRefCursor.IsNull)
					{
						result = true;
					}
					break;
				}
				}
				return result;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.IsProviderSpecificNullValue, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.IsProviderSpecificNullValue);
				}
			}
		}

		internal void SetNullIndicators()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetNullIndicators);
			}
			try
			{
				if (m_value == null)
				{
					m_value = DBNull.Value;
				}
				if (m_bArrayBind)
				{
					m_nullIndicatorsForArrayBind = new bool[m_bindElemCnt];
					if (m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput)
					{
						if (m_value == DBNull.Value || IsProviderSpecificNullValue(m_value))
						{
							for (int i = 0; i < m_bindElemCnt; i++)
							{
								m_nullIndicatorsForArrayBind[i] = true;
							}
							m_IsValueNull = true;
							return;
						}
						int length = ((Array)m_value).Length;
						for (int i = 0; i < m_bindElemCnt; i++)
						{
							if (m_paramImpl.m_arrayBindStatus[i] == OracleParameterStatus.NullInsert)
							{
								m_nullIndicatorsForArrayBind[i] = true;
							}
							else if (length > i && (((Array)m_value).GetValue(i) == null || ((Array)m_value).GetValue(i) == DBNull.Value || (((Array)m_value).GetValue(i) is INullable && ((INullable)((Array)m_value).GetValue(i)).IsNull)))
							{
								m_nullIndicatorsForArrayBind[i] = true;
							}
							else
							{
								m_nullIndicatorsForArrayBind[i] = false;
							}
						}
					}
					else
					{
						for (int i = 0; i < m_bindElemCnt; i++)
						{
							m_nullIndicatorsForArrayBind[i] = false;
						}
					}
				}
				else if (((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && (m_value == DBNull.Value || IsProviderSpecificNullValue(m_value) || m_paramImpl.m_status == OracleParameterStatus.NullInsert)) || m_direction == ParameterDirection.Output)
				{
					m_IsValueNull = true;
				}
				else
				{
					m_IsValueNull = false;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetNullIndicators, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetNullIndicators);
				}
			}
		}

		internal bool IsBindNullValue()
		{
			return m_IsValueNull;
		}

		internal bool IsArrayBindNullValue(int index)
		{
			if (m_nullIndicatorsForArrayBind != null && index < m_nullIndicatorsForArrayBind.Length)
			{
				return m_nullIndicatorsForArrayBind[index];
			}
			return false;
		}

		internal void SetArrayContext(int arrayBindCount)
		{
			int num = 0;
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetArrayContext);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					if (m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput)
					{
						if (m_value != null && m_value != DBNull.Value && m_value is Array)
						{
							if (m_maxSize > 0 && ((Array)m_value).Length > m_maxSize)
							{
								m_bindElemCnt = m_maxSize;
							}
							else
							{
								m_bindElemCnt = ((Array)m_value).Length;
							}
						}
						else
						{
							if (m_paramImpl.m_arrayBindStatus == null)
							{
								throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.ODP_INVALID_VALUE, "OracleParameter.Value"));
							}
							m_bindElemCnt = 0;
							if (m_maxSize > 0 && m_paramImpl.m_arrayBindStatus.Length > m_maxSize)
							{
								m_bindElemCnt = m_maxSize;
							}
							else
							{
								m_bindElemCnt = m_paramImpl.m_arrayBindStatus.Length;
							}
						}
						if (m_bindElemCnt == 0)
						{
							throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.ODP_INVALID_VALUE, "OracleParameter.Value"));
						}
						m_maxNoOfArrayElements = m_bindElemCnt;
						if (m_direction == ParameterDirection.InputOutput && m_maxNoOfArrayElements < m_maxSize)
						{
							m_maxNoOfArrayElements = m_maxSize;
						}
					}
					else
					{
						if (m_maxSize <= 0)
						{
							throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.ODP_INVALID_VALUE, "OracleParameter.Size"));
						}
						m_bindElemCnt = m_maxSize;
						m_maxNoOfArrayElements = m_maxSize;
					}
				}
				else
				{
					m_bindElemCnt = arrayBindCount;
					m_maxNoOfArrayElements = arrayBindCount;
				}
				if (m_direction != ParameterDirection.Input && (OracleDbType == OracleDbType.Char || OracleDbType == OracleDbType.Varchar2 || OracleDbType == OracleDbType.Raw || OracleDbType == OracleDbType.Long || OracleDbType == OracleDbType.NChar || OracleDbType == OracleDbType.NVarchar2 || OracleDbType == OracleDbType.LongRaw) && (m_maxArrayBindSize == null || (m_maxArrayBindSize != null && m_maxArrayBindSize.Length < m_maxSize)))
				{
					throw new InvalidOperationException(OracleStringResourceManager.GetErrorMesg(ResourceStringConstants.ODP_INVALID_VALUE, "OracleParameter.ArrayBindSize"));
				}
				if (m_paramImpl.m_curArrayBindSize == null || m_paramImpl.m_curArrayBindSize.Length != m_maxNoOfArrayElements)
				{
					m_paramImpl.m_curArrayBindSize = new int[m_maxNoOfArrayElements];
					for (num = 0; num < m_maxNoOfArrayElements; num++)
					{
						m_paramImpl.m_curArrayBindSize[num] = -1;
					}
				}
				if (m_maxArrayBindSize == null)
				{
					m_maxArrayBindSize = new int[m_maxNoOfArrayElements];
					for (num = 0; num < m_maxNoOfArrayElements; num++)
					{
						m_maxArrayBindSize[num] = -1;
					}
				}
				else if (m_maxArrayBindSize.Length < m_maxNoOfArrayElements)
				{
					int[] array = new int[m_maxNoOfArrayElements];
					for (num = 0; num < m_maxArrayBindSize.Length; num++)
					{
						array[num] = m_maxArrayBindSize[num];
					}
					for (; num < m_maxNoOfArrayElements; num++)
					{
						array[num] = -1;
					}
					m_maxArrayBindSize = array;
				}
				if (m_paramImpl.m_arrayBindStatus == null)
				{
					m_paramImpl.m_arrayBindStatus = new OracleParameterStatus[m_maxNoOfArrayElements];
					for (num = 0; num < m_maxNoOfArrayElements; num++)
					{
						m_paramImpl.m_arrayBindStatus[num] = OracleParameterStatus.Success;
					}
				}
				else if (m_paramImpl.m_arrayBindStatus.Length < m_maxNoOfArrayElements)
				{
					OracleParameterStatus[] array2 = new OracleParameterStatus[m_maxNoOfArrayElements];
					for (num = 0; num < m_paramImpl.m_arrayBindStatus.Length; num++)
					{
						array2[num] = m_paramImpl.m_arrayBindStatus[num];
					}
					for (; num < m_maxNoOfArrayElements; num++)
					{
						array2[num] = OracleParameterStatus.Success;
					}
					m_paramImpl.m_arrayBindStatus = array2;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetArrayContext, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.SetArrayContext);
				}
			}
		}

		private void PreBind_Char(OracleConnectionImpl connImpl, SqlStatementType stmtType)
		{
			int[] array = null;
			int num = 0;
			int num2 = 0;
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Char);
			}
			try
			{
				m_oraType = OraType.ORA_CHARN;
				if (m_oraDbType == OracleDbType.Char || m_oraDbType == OracleDbType.NChar)
				{
					m_oraType = OraType.ORA_CHAR;
				}
				int maxBytesPerChar = connImpl.m_marshallingEngine.m_dbCharSetConv.MaxBytesPerChar;
				if (m_charSetForm == 2)
				{
					maxBytesPerChar = connImpl.m_marshallingEngine.m_nCharSetConv.MaxBytesPerChar;
				}
				if (m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput)
				{
					if (!m_IsValueNull)
					{
						if (!m_bArrayBind)
						{
							num2 = (num = GetBindingSize_Char(0));
							if (m_direction == ParameterDirection.InputOutput && num < m_maxSize)
							{
								num2 = m_maxSize;
							}
						}
						else
						{
							array = new int[m_bindElemCnt];
							for (int i = 0; i < m_bindElemCnt; i++)
							{
								if (m_nullIndicatorsForArrayBind[i])
								{
									array[i] = 0;
								}
								else
								{
									array[i] = GetBindingSize_Char(i);
								}
								if (num2 < array[i])
								{
									num2 = array[i];
								}
								if (m_direction == ParameterDirection.InputOutput && m_maxArrayBindSize != null && num2 < m_maxArrayBindSize[i])
								{
									num2 = m_maxArrayBindSize[i];
								}
							}
						}
						if (!m_bArrayBind)
						{
							m_paramImpl.SetCharDataInBytes(connImpl, m_value, num, m_offset, m_charSetForm);
						}
						else
						{
							m_paramImpl.SetCharDataArrayInBytes(connImpl, m_value, array, m_offset, m_bindElemCnt, m_nullIndicatorsForArrayBind, m_charSetForm);
						}
						if (m_direction == ParameterDirection.InputOutput)
						{
							MaxBytesToBeWrittenOrRead = num2 * maxBytesPerChar;
							MaxCharsToBeWrittenOrRead = num2;
						}
						else
						{
							MaxBytesToBeWrittenOrRead = num2 * maxBytesPerChar;
							MaxCharsToBeWrittenOrRead = num2;
						}
					}
					else if (m_direction == ParameterDirection.InputOutput)
					{
						MaxBytesToBeWrittenOrRead = m_maxSize * maxBytesPerChar;
						MaxCharsToBeWrittenOrRead = m_maxSize;
					}
				}
				else if (m_bArrayBind)
				{
					if (m_maxArrayBindSize != null)
					{
						num2 = m_maxArrayBindSize[0];
						for (int j = 1; j < m_bindElemCnt; j++)
						{
							if (m_maxArrayBindSize[j] > num2)
							{
								num2 = m_maxArrayBindSize[j];
							}
						}
						if (num2 == -1)
						{
							num2 = 0;
						}
					}
					else
					{
						num2 = 0;
					}
					MaxBytesToBeWrittenOrRead = num2 * maxBytesPerChar;
					MaxCharsToBeWrittenOrRead = num2;
				}
				else
				{
					MaxBytesToBeWrittenOrRead = m_maxSize * maxBytesPerChar;
					MaxCharsToBeWrittenOrRead = m_maxSize;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Char, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Char);
				}
			}
		}

		private void PreBind_BDouble()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BDouble);
			}
			try
			{
				m_oraType = OraType.ORA_IBDOUBLE;
				m_maxBytesToBeWrittenOrRead = 8;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetBinaryDoubleInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetBinaryDoubleArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BDouble, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BDouble);
				}
			}
		}

		private void PreBind_BFloat()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BFloat);
			}
			try
			{
				m_oraType = OraType.ORA_IBFLOAT;
				m_maxBytesToBeWrittenOrRead = 4;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetBinaryFloatInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetBinaryFloatArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BFloat, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BFloat);
				}
			}
		}

		private void PreBind_Int32()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Int32);
			}
			try
			{
				m_oraType = OraType.ORA_NUMBER;
				m_maxBytesToBeWrittenOrRead = 22;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetInt32DataInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetInt32ArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Int32, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Int32);
				}
			}
		}

		private void PreBind_Int64()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Int64);
			}
			try
			{
				m_oraType = OraType.ORA_NUMBER;
				m_maxBytesToBeWrittenOrRead = 22;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetInt64DataInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetInt64ArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Int64, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Int64);
				}
			}
		}

		private void PreBind_Double()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Double);
			}
			try
			{
				m_oraType = OraType.ORA_NUMBER;
				m_maxBytesToBeWrittenOrRead = 22;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetDoubleInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetDoubleArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Double, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Double);
				}
			}
		}

		private void PreBind_Single()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Single);
			}
			try
			{
				m_oraType = OraType.ORA_NUMBER;
				m_maxBytesToBeWrittenOrRead = 22;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetSingleInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetSingleArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Single, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Single);
				}
			}
		}

		private void PreBind_Decimal()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Decimal);
			}
			try
			{
				m_oraType = OraType.ORA_NUMBER;
				m_maxBytesToBeWrittenOrRead = 22;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetDecimalDataInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetDecimalArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Decimal, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Decimal);
				}
			}
		}

		private void PreBind_Date()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Date);
			}
			try
			{
				m_oraType = OraType.ORA_DATE;
				m_maxBytesToBeWrittenOrRead = 7;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetDateInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetDateArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Date, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Date);
				}
			}
		}

		private void PreBind_TimeStamp()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStamp);
			}
			try
			{
				m_oraType = OraType.ORA_TIMESTAMP_DTY;
				m_maxBytesToBeWrittenOrRead = 11;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetTimeStampInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetTimeStampArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStamp, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStamp);
				}
			}
		}

		private void PreBind_TimeStampLTZ(OracleConnectionImpl connImpl)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStampLTZ);
			}
			try
			{
				m_oraType = OraType.ORA_TIMESTAMP_LTZ_DTY;
				m_maxBytesToBeWrittenOrRead = 11;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetTimeStampLTZInBytes(connImpl, m_value);
					}
					else
					{
						m_paramImpl.SetTimeStampLTZArrayInBytes(connImpl, m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStampLTZ, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStampLTZ);
				}
			}
		}

		private void PreBind_TimeStampTZ(OracleConnectionImpl connImpl)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStampTZ);
			}
			try
			{
				m_oraType = OraType.ORA_TIMESTAMP_TZ_DTY;
				m_maxBytesToBeWrittenOrRead = 13;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetTimeStampTZInBytes(connImpl, m_value);
					}
					else
					{
						m_paramImpl.SetTimeStampTZArrayInBytes(connImpl, m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStampTZ, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_TimeStampTZ);
				}
			}
		}

		private void PreBind_IntervalDS()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_IntervalDS);
			}
			try
			{
				m_oraType = OraType.ORA_INTERVAL_DS_DTY;
				m_maxBytesToBeWrittenOrRead = 11;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetIntervalDSInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetIntervalDSArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_IntervalDS, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_IntervalDS);
				}
			}
		}

		private void PreBind_IntervalYM()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_IntervalYM);
			}
			try
			{
				m_oraType = OraType.ORA_INTERVAL_YM_DTY;
				m_maxBytesToBeWrittenOrRead = 5;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetIntervalYMInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetIntervalYMArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_IntervalYM, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_IntervalYM);
				}
			}
		}

		private void PreBind_Raw()
		{
			m_oraType = OraType.ORA_RAW;
			int[] array = null;
			int num = 0;
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Raw);
			}
			try
			{
				if (m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput)
				{
					if (!m_IsValueNull)
					{
						if (!m_bArrayBind)
						{
							num = GetBindingSize_Raw(0);
							m_paramImpl.SetRawDataInBytes(m_value, num, m_offset);
							MaxBytesToBeWrittenOrRead = num;
							if (m_direction == ParameterDirection.InputOutput && num < m_maxSize)
							{
								MaxBytesToBeWrittenOrRead = m_maxSize;
							}
							return;
						}
						array = new int[m_bindElemCnt];
						for (int i = 0; i < m_bindElemCnt; i++)
						{
							if (m_nullIndicatorsForArrayBind[i])
							{
								array[i] = 0;
							}
							else
							{
								array[i] = GetBindingSize_Raw(i);
							}
							if (num < array[i])
							{
								num = array[i];
							}
							if (m_direction == ParameterDirection.InputOutput && m_maxArrayBindSize != null && num < m_maxArrayBindSize[i])
							{
								num = m_maxArrayBindSize[i];
							}
						}
						MaxBytesToBeWrittenOrRead = num;
						m_paramImpl.SetRawDataArrayInBytes(m_value, array, m_offset, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
					else if (m_direction == ParameterDirection.InputOutput)
					{
						MaxBytesToBeWrittenOrRead = m_maxSize;
					}
				}
				else if (m_bArrayBind)
				{
					if (m_maxArrayBindSize != null)
					{
						num = m_maxArrayBindSize[0];
						for (int j = 1; j < m_bindElemCnt; j++)
						{
							if (m_maxArrayBindSize[j] > num)
							{
								num = m_maxArrayBindSize[j];
							}
						}
						if (num == -1)
						{
							num = 0;
						}
					}
					MaxBytesToBeWrittenOrRead = num;
				}
				else
				{
					MaxBytesToBeWrittenOrRead = m_maxSize;
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Raw, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Raw);
				}
			}
		}

		private void PreBind_Clob(OracleConnectionImpl connImpl, bool isEFSelectStatement, SqlStatementType stmtType)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Clob);
			}
			try
			{
				m_maxBytesToBeWrittenOrRead = 4000;
				if (m_bArrayBind || m_direction != ParameterDirection.Input || m_value is OracleClob)
				{
					goto IL_00a7;
				}
				int num = m_maxBytesToBeWrittenOrRead;
				int num2 = 0;
				if (!m_IsValueNull)
				{
					num2 = GetBindingSize_Char(0);
				}
				if (m_charSetForm == 2)
				{
					num /= 2;
				}
				if ((num2 >= num || num2 <= 0) && !(num2 == 0 && isEFSelectStatement))
				{
					goto IL_00a7;
				}
				m_IsValueNull = ((num2 <= 0) ? true : false);
				m_maxBytesToBeWrittenOrRead = 1;
				m_maxCharsToBeWrittenOrRead = 0;
				PreBind_Char(connImpl, stmtType);
				goto end_IL_001f;
				IL_00a7:
				m_oraType = OraType.ORA_OCICLobLocator;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					bool bIsNClob = m_charSetForm != 1;
					if (!m_bArrayBind)
					{
						m_paramImpl.SetClobDataInBytes(connImpl, bIsNClob, m_value, m_offset, m_maxSize, m_maxArrayBindSize);
					}
					else
					{
						m_paramImpl.SetClobArrayDataInBytes(connImpl, bIsNClob, m_value, m_offset, m_maxSize, m_maxArrayBindSize, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
				end_IL_001f:;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Clob, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Clob);
				}
			}
		}

		private void PreBind_BFile(OracleConnectionImpl connImpl)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BFile);
			}
			try
			{
				m_oraType = OraType.ORA_OCIBFileLocator;
				m_maxBytesToBeWrittenOrRead = 4000;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetBFileDataInBytes(connImpl, m_value);
					}
					else
					{
						m_paramImpl.SetBFileArrayInBytes(connImpl, m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BFile, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_BFile);
				}
			}
		}

		private void PreBind_Blob(OracleConnectionImpl connImpl, bool isEFSelectStatement)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Blob);
			}
			try
			{
				m_maxBytesToBeWrittenOrRead = 4000;
				if (m_IsValueNull || m_bArrayBind || m_direction != ParameterDirection.Input || m_value is OracleBlob)
				{
					goto IL_0089;
				}
				int bindingSize_Raw = GetBindingSize_Raw(0);
				if ((bindingSize_Raw >= m_maxBytesToBeWrittenOrRead || bindingSize_Raw <= 0) && !(bindingSize_Raw == 0 && isEFSelectStatement))
				{
					goto IL_0089;
				}
				if (bindingSize_Raw == 0)
				{
					m_IsValueNull = true;
				}
				PreBind_Raw();
				m_IsValueNull = false;
				goto end_IL_001f;
				IL_0089:
				m_oraType = OraType.ORA_OCIBLobLocator;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetBlobDataInBytes(connImpl, m_value, m_offset, m_maxSize, m_maxArrayBindSize);
					}
					else
					{
						m_paramImpl.SetBlobArrayDataInBytes(connImpl, m_value, m_offset, m_maxSize, m_maxArrayBindSize, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
				end_IL_001f:;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Blob, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Blob);
				}
			}
		}

		private void PreBind_Json(OracleConnectionImpl connImpl)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Json);
			}
			try
			{
				m_maxBytesToBeWrittenOrRead = 33554432;
				m_oraType = OraType.ORA_OCIJSON;
				if ((m_direction != ParameterDirection.Input && m_direction != ParameterDirection.InputOutput) || m_IsValueNull)
				{
					return;
				}
				if (!m_bArrayBind)
				{
					m_IsValueNull = m_paramImpl.IsJsonDataNullValue(m_value);
					if (!m_IsValueNull)
					{
						m_paramImpl.SetJsonDataInBytes(connImpl, m_value);
					}
				}
				else
				{
					m_paramImpl.SetJsonArrayInBytes(connImpl, m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Json, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Json);
				}
			}
		}

		private void PreBind_XmlType(OracleConnectionImpl connImpl)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_XmlType);
			}
			try
			{
				m_oraType = OraType.ORA_INTY;
				m_maxBytesToBeWrittenOrRead = 11;
				m_maxCharsToBeWrittenOrRead = 0;
				m_charSetForm = 0;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetXmlTypeInBytes(connImpl, m_value, m_offset, m_maxSize, m_maxArrayBindSize);
					}
					else
					{
						m_paramImpl.SetXmlTypeArrayInBytes(connImpl, m_value, m_offset, m_maxSize, m_maxArrayBindSize, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_XmlType, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_XmlType);
				}
			}
		}

		private void PreBind_Cursor(OracleConnectionImpl connImpl)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Cursor);
			}
			try
			{
				m_oraType = OraType.ORA_REFCURSOR;
				m_maxBytesToBeWrittenOrRead = 1;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetRefCursorDataInBytes(connImpl, m_value);
					}
					else
					{
						m_paramImpl.SetRefCursorArrayInBytes(connImpl, m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Cursor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Cursor);
				}
			}
		}

		private void PreBind_Boolean()
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Boolean);
			}
			try
			{
				m_oraType = OraType.ORA_BOOLEAN;
				m_maxBytesToBeWrittenOrRead = 2;
				if ((m_direction == ParameterDirection.Input || m_direction == ParameterDirection.InputOutput) && !m_IsValueNull)
				{
					if (!m_bArrayBind)
					{
						m_paramImpl.SetPlsqlBooleanDataInBytes(m_value);
					}
					else
					{
						m_paramImpl.SetPlsqlBooleanArrayInBytes(m_value, m_bindElemCnt, m_nullIndicatorsForArrayBind);
					}
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Boolean, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PreBind_Boolean);
				}
			}
		}

		internal void PostBind_Boolean(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Boolean);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetPlsqlBooleanFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_oraDbType);
				}
				else
				{
					m_value = m_paramImpl.GetPlsqlBooleanArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_oraDbType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Boolean, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Boolean);
				}
			}
		}

		internal void PostBind_Char(OracleConnectionImpl connImpl, Accessor bindAccessor, char[] charArrayFromPooler)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Char);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetCharDataFromBytesInPLSQLArray(connImpl, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_maxArrayBindSize, m_charSetForm, charArrayFromPooler);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetCharDataFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_charSetForm, m_maxCharsToBeWrittenOrRead, charArrayFromPooler);
				}
				else
				{
					m_value = m_paramImpl.GetCharArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_charSetForm, m_maxArrayBindSize, m_bindElemCnt, charArrayFromPooler);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Char, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Char);
				}
			}
		}

		internal void PostBind_RefCursor(OracleConnection connection, Accessor bindAccessor, long fetchSize, OracleIntervalDS sessionTimeZone, string commandText, string paramPosOrName, long longFetchSize, long clientInitialLOBFS, long internalInitialLOBFS, long internalInitialJSONFS, long[] scnFromExecution, bool bCallFromExecuteReader)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_RefCursor);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetRefCursorFromBytes(connection, bindAccessor, fetchSize, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, sessionTimeZone, commandText, paramPosOrName, longFetchSize, clientInitialLOBFS, internalInitialLOBFS, internalInitialJSONFS, scnFromExecution, bCallFromExecuteReader);
				}
				else
				{
					m_value = m_paramImpl.GetRefCursorArrayFromBytes(connection, bindAccessor, fetchSize, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, sessionTimeZone, commandText, paramPosOrName, longFetchSize, clientInitialLOBFS, internalInitialLOBFS, internalInitialJSONFS, scnFromExecution, m_bindElemCnt, bCallFromExecuteReader);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_RefCursor, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_RefCursor);
				}
			}
		}

		internal void PostBind_Lob(OracleConnection connection, Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Lob);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_paramImpl.GetLobDataFromBytes(connection, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_oraType, ref m_value, m_direction == ParameterDirection.InputOutput, m_charSetForm);
				}
				else
				{
					m_paramImpl.GetLobArrayFromBytes(connection, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_oraType, ref m_value, m_direction == ParameterDirection.InputOutput, m_charSetForm, m_bindElemCnt);
				}
				m_paramImpl.m_saveValue = null;
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Lob, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Lob);
				}
			}
		}

		internal void PostBind_Json(OracleConnection connection, Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Json);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetJsonFromBytes(connection, bindAccessor, m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetJsonArrayFromBytes(connection, bindAccessor, m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Json, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Json);
				}
			}
		}

		internal void PostBind_TimeStamp(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStamp);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetTimeStampFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetTimeStampArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStamp, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStamp);
				}
			}
		}

		internal void PostBind_TimeStampLTZ(OracleConnectionImpl connImpl, Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStampLTZ);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetTimeStampLTZFromBytes(connImpl, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetTimeStampLTZArrayFromBytes(connImpl, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStampLTZ, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStampLTZ);
				}
			}
		}

		internal void PostBind_TimeStampTZ(OracleConnectionImpl connImpl, Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStampTZ);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetTimeStampTZFromBytes(connImpl, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bReturnDateTimeOffset);
				}
				else
				{
					m_value = m_paramImpl.GetTimeStampTZArrayFromBytes(connImpl, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt, m_bReturnDateTimeOffset);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStampTZ, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_TimeStampTZ);
				}
			}
		}

		internal void PostBind_Raw(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Raw);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetRawDataFromBytesInPlSqlArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetRawDataFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_maxBytesToBeWrittenOrRead);
				}
				else
				{
					m_value = m_paramImpl.GetRawArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_maxArrayBindSize, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Raw, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Raw);
				}
			}
		}

		internal void PostBind_Int32(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Int32);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetInt32FromBytesInPLSQLArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetIntFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_oraDbType);
				}
				else
				{
					m_value = m_paramImpl.GetIntArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_oraDbType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Int32, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Int32);
				}
			}
		}

		internal void PostBind_Int64(object bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Int64);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetLongFromBytesInPLSQLArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetLongFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetLongArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Int64, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Int64);
				}
			}
		}

		internal void PostBind_Decimal(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Decimal);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetDecimalFromBytesInPLSQLArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetDecimalFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetDecimalArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Decimal, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Decimal);
				}
			}
		}

		internal void PostBind_Single(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Single);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetSingleFromBytesInPLSQLArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetSingleFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetSingleArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Single, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Single);
				}
			}
		}

		internal void PostBind_BinaryFloat(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_BinaryFloat);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetBinaryFloatFromBytesInPLSQLArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetBinaryFloatFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetBinaryFloatArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_BinaryFloat, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_BinaryFloat);
				}
			}
		}

		internal void PostBind_BinaryDouble(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_BinaryDouble);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetBinaryDoubleFromBytesInPLSQLArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetBinaryDoubleFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetBinaryDoubleArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_BinaryDouble, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_BinaryDouble);
				}
			}
		}

		internal void PostBind_Double(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Double);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetDoubleFromBytesInPLSQLArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetDoubleFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetDoubleArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Double, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Double);
				}
			}
		}

		internal void PostBind_Date(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Date);
			}
			try
			{
				if (m_collType == OracleCollectionType.PLSQLAssociativeArray)
				{
					m_value = m_paramImpl.GetDateFromBytesInPLSQLArray(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetDateFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetDateArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Date, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_Date);
				}
			}
		}

		internal void PostBind_IntervalDS(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_IntervalDS);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetIntervalDSFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetIntervalDSArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_IntervalDS, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_IntervalDS);
				}
			}
		}

		internal void PostBind_IntervalYM(Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_IntervalYM);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_value = m_paramImpl.GetIntervalYMFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType);
				}
				else
				{
					m_value = m_paramImpl.GetIntervalYMArrayFromBytes(bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_IntervalYM, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_IntervalYM);
				}
			}
		}

		internal void PostBind_XmlType(OracleConnection connection, Accessor bindAccessor)
		{
			if (ProviderConfig.m_bTraceLevelPrivate)
			{
				Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Entry, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_XmlType);
			}
			try
			{
				if (!m_bArrayBind)
				{
					m_paramImpl.GetXmlTypeDataFromBytes(connection, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_oraType, ref m_value, m_direction == ParameterDirection.InputOutput);
				}
				else
				{
					m_paramImpl.GetXmlTypeArrayFromBytes(connection, bindAccessor, m_bOracleDbTypeExSet ? PrmEnumType.DBTYPE : m_enumType, m_oraType, ref m_value, m_direction == ParameterDirection.InputOutput, m_bindElemCnt);
				}
			}
			catch (Exception ex)
			{
				OracleException.HandleError(OracleTraceLevel.Private, OracleTraceTag.Error, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_XmlType, ex);
				throw;
			}
			finally
			{
				if (ProviderConfig.m_bTraceLevelPrivate)
				{
					Trace.Write(OracleTraceLevel.Private, OracleTraceTag.Exit, OracleTraceClassName.OracleParameter, OracleTraceFuncName.PostBind_XmlType);
				}
			}
		}
	}
}
